JavaScript asinhrono ģeneratoru palīgu apgūšana: straumju utilītas modernai izstrādei

JavaScript asinhrono ģeneratoru palīgi, kas ieviesti ES2023, nodrošina jaudīgus un intuitīvus rīkus darbam ar asinhronām datu straumēm. Šīs utilītas vienkāršo bieži sastopamus datu apstrādes uzdevumus, padarot jūsu kodu lasāmāku, uzturamāku un efektīvāku. Šī visaptverošā rokasgrāmata pēta šos palīgus, piedāvājot praktiskus piemērus un atziņas visu līmeņu izstrādātājiem.

Kas ir asinhronie ģeneratori un asinhronie iteratori?

Pirms iedziļināties palīgos, īsi atkārtosim, kas ir asinhronie ģeneratori un asinhronie iteratori. Asinhronais ģenerators ir funkcija, kas var apturēt izpildi un atgriezt asinhronas vērtības. Tā atgriež asinhrono iteratoru, kas nodrošina veidu, kā asinhroni iterēt pār šīm vērtībām.

Šeit ir pamata piemērs:

            
async function* generateNumbers(max) {
  for (let i = 0; i < max; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    yield i;
  }
}

async function main() {
  const numberStream = generateNumbers(5);

  for await (const number of numberStream) {
    console.log(number); // Output: 0, 1, 2, 3, 4 (with delays)
  }
}

main();

            

              
                Copy
              
            
          

Šajā piemērā `generateNumbers` ir asinhronā ģeneratora funkcija. Tā atgriež skaitļus no 0 līdz `max` (neieskaitot), ar 500 ms aizkavi starp katru atgriešanu. `for await...of` cikls iterē pār asinhrono iteratoru, ko atgriež `generateNumbers`.

Iepazīstinām ar asinhrono ģeneratoru palīgiem

Asinhrono ģeneratoru palīgi paplašina asinhrono iteratoru funkcionalitāti, piedāvājot metodes datu plūsmas transformēšanai, filtrēšanai un kontrolei asinhronās straumēs. Šie palīgi ir izstrādāti tā, lai tos varētu apvienot, ļaujot jums savienot operācijas ķēdē sarežģītiem datu apstrādes konveijeriem.

Galvenie asinhrono ģeneratoru palīgi ir:

• `AsyncIterator.prototype.filter(predicate)`: Izveido jaunu asinhrono iteratoru, kas atgriež tikai tās vērtības, kurām `predicate` funkcija atgriež patiesu (truthy) vērtību.
• `AsyncIterator.prototype.map(transform)`: Izveido jaunu asinhrono iteratoru, kas atgriež rezultātus, kas iegūti, izsaucot `transform` funkciju katrai vērtībai.
• `AsyncIterator.prototype.take(limit)`: Izveido jaunu asinhrono iteratoru, kas atgriež tikai pirmās `limit` vērtības.
• `AsyncIterator.prototype.drop(amount)`: Izveido jaunu asinhrono iteratoru, kas izlaiž pirmās `amount` vērtības.
• `AsyncIterator.prototype.forEach(callback)`: Izpilda norādīto funkciju vienu reizi katrai vērtībai no asinhronā iteratora. Šī ir termināla operācija (patērē iteratoru).
• `AsyncIterator.prototype.toArray()`: Apkopo visas vērtības no asinhronā iteratora masīvā. Šī ir termināla operācija.
• `AsyncIterator.prototype.reduce(reducer, initialValue)`: Piemēro funkciju akumulatoram un katrai asinhronā iteratora vērtībai, lai to reducētu līdz vienai vērtībai. Šī ir termināla operācija.
• `AsyncIterator.from(iterable)`: Izveido asinhrono iteratoru no sinhronā iterējamā objekta vai cita asinhronā iterējamā objekta.

Praktiski piemēri

Apskatīsim šos palīgus ar praktiskiem piemēriem.

Datu filtrēšana ar `filter()`

Pieņemsim, ka jums ir asinhronais ģenerators, kas atgriež sensoru rādījumu straumi, un jūs vēlaties filtrēt rādījumus, kas ir zemāki par noteiktu slieksni.

            
async function* getSensorReadings() {
  // Simulate fetching sensor data from a remote source
  yield 20;
  yield 15;
  yield 25;
  yield 10;
  yield 30;
}

async function main() {
  const readings = getSensorReadings();
  const filteredReadings = readings.filter(reading => reading >= 20);

  for await (const reading of filteredReadings) {
    console.log(reading); // Output: 20, 25, 30
  }
}

main();

            

              
                Copy
              
            
          

`filter()` palīgs izveido jaunu asinhrono iteratoru, kas atgriež tikai tos rādījumus, kas ir lielāki vai vienādi ar 20.

Datu transformēšana ar `map()`

Pieņemsim, ka jums ir asinhronais ģenerators, kas atgriež temperatūras vērtības Celsija grādos, un jūs vēlaties tās pārvērst Fārenheita grādos.

            
async function* getCelsiusTemperatures() {
  yield 0;
  yield 10;
  yield 20;
  yield 30;
}

async function main() {
  const celsiusTemperatures = getCelsiusTemperatures();
  const fahrenheitTemperatures = celsiusTemperatures.map(celsius => (celsius * 9/5) + 32);

  for await (const fahrenheit of fahrenheitTemperatures) {
    console.log(fahrenheit); // Output: 32, 50, 68, 86
  }
}

main();

            

              
                Copy
              
            
          

`map()` palīgs katrai temperatūras vērtībai piemēro Celsija-Fārenheita konvertēšanas funkciju.

Datu ierobežošana ar `take()`

Ja jums nepieciešams tikai noteikts vērtību skaits no asinhronā ģeneratora, varat izmantot `take()` palīgu.

            
async function* getLogEntries() {
  // Simulate reading log entries from a file
  yield 'Log entry 1';
  yield 'Log entry 2';
  yield 'Log entry 3';
  yield 'Log entry 4';
  yield 'Log entry 5';
}

async function main() {
  const logEntries = getLogEntries();
  const firstThreeEntries = logEntries.take(3);

  for await (const entry of firstThreeEntries) {
    console.log(entry); // Output: Log entry 1, Log entry 2, Log entry 3
  }
}

main();

            

              
                Copy
              
            
          

`take(3)` palīgs ierobežo izvadi ar pirmajiem trim žurnāla ierakstiem.

Datu izlaišana ar `drop()`

`drop()` palīgs ļauj izlaist noteiktu skaitu vērtību no asinhronā iteratora sākuma.

            
async function* getItems() {
  yield 'Item 1';
  yield 'Item 2';
  yield 'Item 3';
  yield 'Item 4';
  yield 'Item 5';
}

async function main() {
  const items = getItems();
  const remainingItems = items.drop(2);

  for await (const item of remainingItems) {
    console.log(item); // Output: Item 3, Item 4, Item 5
  }
}

main();

            

              
                Copy
              
            
          

`drop(2)` palīgs izlaiž pirmos divus elementus.

Blakusefektu veikšana ar `forEach()`

`forEach()` palīgs ļauj izpildīt atzvanīšanas funkciju katram asinhronā iteratora elementam. Ir svarīgi atcerēties, ka šī ir termināla operācija; pēc `forEach` izsaukšanas iterators tiek patērēts.

            
async function* getDataPoints() {
  yield 1;
  yield 2;
  yield 3;
}

async function main() {
  const dataPoints = getDataPoints();

  await dataPoints.forEach(dataPoint => {
    console.log(`Processing data point: ${dataPoint}`);
  });

  // The iterator is now consumed.
}

main();

            

              
                Copy
              
            
          

Vērtību apkopošana masīvā ar `toArray()`

`toArray()` palīgs apkopo visas vērtības no asinhronā iteratora masīvā. Šī ir vēl viena termināla operācija.

            
async function* getFruits() {
  yield 'apple';
  yield 'banana';
  yield 'orange';
}

async function main() {
  const fruits = getFruits();
  const fruitArray = await fruits.toArray();

  console.log(fruitArray); // Output: ['apple', 'banana', 'orange']
}

main();

            

              
                Copy
              
            
          

Vērtību reducēšana līdz vienam rezultātam ar `reduce()`

`reduce()` palīgs piemēro funkciju akumulatoram un katrai asinhronā iteratora vērtībai, lai to reducētu līdz vienai vērtībai. Šī ir termināla operācija.

            
async function* getNumbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
}

async function main() {
  const numbers = getNumbers();
  const sum = await numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);

  console.log(sum); // Output: 10
}

main();

            

              
                Copy
              
            
          

Asinhrono iteratoru izveide no esošiem iterējamiem objektiem ar `from()`

`from()` palīgs ļauj viegli izveidot asinhrono iteratoru no sinhronā iterējamā objekta (piemēram, masīva) vai cita asinhronā iterējamā objekta.

            
async function main() {
  const syncArray = [1, 2, 3];
  const asyncIteratorFromArray = AsyncIterator.from(syncArray);

  for await (const number of asyncIteratorFromArray) {
    console.log(number); // Output: 1, 2, 3
  }

  async function* asyncGenerator() {
    yield 4;
    yield 5;
    yield 6;
  }

  const asyncIteratorFromGenerator = AsyncIterator.from(asyncGenerator());

  for await (const number of asyncIteratorFromGenerator) {
    console.log(number); // Output: 4, 5, 6
  }
}

main();

            

              
                Copy
              
            
          

Asinhrono ģeneratoru palīgu apvienošana

Asinhrono ģeneratoru palīgu patiesais spēks slēpjas to spējā tos apvienot. Jūs varat savienot vairākus palīgus ķēdē, lai izveidotu sarežģītus datu apstrādes konveijerus.

Piemēram, pieņemsim, ka vēlaties iegūt lietotāju datus no API, filtrēt neaktīvos lietotājus un pēc tam iegūt viņu e-pasta adreses.

            
async function* fetchUsers() {
  // Simulate fetching user data from an API
  yield { id: 1, name: 'Alice', email: 'alice@example.com', active: true };
  yield { id: 2, name: 'Bob', email: 'bob@example.com', active: false };
  yield { id: 3, name: 'Charlie', email: 'charlie@example.com', active: true };
  yield { id: 4, name: 'David', email: 'david@example.com', active: false };
}

async function main() {
  const users = fetchUsers();

  const activeUserEmails = users
    .filter(user => user.active)
    .map(user => user.email);

  for await (const email of activeUserEmails) {
    console.log(email); // Output: alice@example.com, charlie@example.com
  }
}

main();

            

              
                Copy
              
            
          

Šis piemērs savieno `filter()` un `map()` ķēdē, lai efektīvi apstrādātu lietotāju datu straumi.

Kļūdu apstrāde

Strādājot ar asinhrono ģeneratoru palīgiem, ir svarīgi pareizi apstrādāt kļūdas. Jūs varat izmantot `try...catch` blokus, lai notvertu izņēmumus, kas radušies ģeneratorā vai palīgfunkcijās.

            
async function* generateData() {
  yield 1;
  yield 2;
  throw new Error('Something went wrong!');
  yield 3;
}

async function main() {
  const dataStream = generateData();

  try {
    for await (const data of dataStream) {
      console.log(data);
    }
  } catch (error) {
    console.error(`Error: ${error.message}`);
  }
}

main();

            

              
                Copy
              
            
          

Lietošanas gadījumi un globāls pielietojums

Asinhrono ģeneratoru palīgi ir piemērojami daudzos scenārijos, īpaši strādājot ar lielām datu kopām vai asinhroniem datu avotiem. Šeit ir daži piemēri:

• Reāllaika datu apstrāde: Straumēšanas datu apstrāde no IoT ierīcēm vai finanšu tirgiem. Piemēram, sistēma, kas uzrauga gaisa kvalitāti pilsētās visā pasaulē, varētu izmantot asinhrono ģeneratoru palīgus, lai filtrētu kļūdainus rādījumus un aprēķinātu slīdošos vidējos rādītājus.
• Datu ievades konveijeri: Datu transformēšana un validēšana, kad tie tiek ievadīti datubāzē no dažādiem avotiem. Iedomājieties globālu e-komercijas platformu, kas izmanto šos palīgus, lai attīrītu un standartizētu produktu aprakstus no dažādiem piegādātājiem.
• Lielu failu apstrāde: Lielu failu lasīšana un apstrāde pa daļām, neielādējot visu failu atmiņā. No tā varētu gūt labumu projekts, kas analizē globālos klimata datus, kas glabājas milzīgos CSV failos.
• API lapošana: Efektīva lapotu API atbilžu apstrāde. Sociālo mediju analītikas rīks, kas iegūst datus no vairākām platformām ar dažādām lapošanas shēmām, varētu izmantot asinhrono ģeneratoru palīgus, lai vienkāršotu procesu.
• Server-Sent Events (SSE) un WebSockets: Reāllaika datu straumju pārvaldība no serveriem. Tiešraides tulkošanas pakalpojums, kas saņem tekstu no runātāja vienā valodā un straumē tulkoto tekstu lietotājiem visā pasaulē, varētu izmantot šos palīgus.

Labākās prakses

• Izprotiet datu plūsmu: Vizualizējiet, kā dati plūst caur jūsu asinhrono ģeneratoru konveijeriem, lai optimizētu veiktspēju.
• Apstrādājiet kļūdas saudzīgi: Ieviesiet robustu kļūdu apstrādi, lai novērstu negaidītas lietojumprogrammas avārijas.
• Izmantojiet atbilstošus palīgus: Izvēlieties vispiemērotākos palīgus savām konkrētajām datu apstrādes vajadzībām. Izvairieties no pārmērīgi sarežģītām palīgu ķēdēm, ja pastāv vienkāršāki risinājumi.
• Rūpīgi testējiet: Rakstiet vienības testus, lai nodrošinātu, ka jūsu asinhrono ģeneratoru konveijeri darbojas pareizi. Pievērsiet īpašu uzmanību robežgadījumiem un kļūdu nosacījumiem.
• Apsveriet veiktspēju: Lai gan asinhrono ģeneratoru palīgi piedāvā uzlabotu lasāmību, esiet uzmanīgi attiecībā uz iespējamo veiktspējas ietekmi, strādājot ar ārkārtīgi lielām datu kopām. Pēc nepieciešamības mēriet un optimizējiet savu kodu.

Alternatīvas

Lai gan asinhrono ģeneratoru palīgi nodrošina ērtu veidu darbam ar asinhronām straumēm, pastāv alternatīvas bibliotēkas un pieejas:

• RxJS (Reactive Extensions for JavaScript): Jaudīga bibliotēka reaktīvai programmēšanai, kas nodrošina bagātīgu operatoru kopumu asinhronu datu straumju transformēšanai un komponēšanai. RxJS ir sarežģītāka nekā asinhrono ģeneratoru palīgi, bet piedāvā lielāku elastību un kontroli.
• Highland.js: Vēl viena straumju apstrādes bibliotēka JavaScript, kas piedāvā funkcionālāku pieeju darbam ar asinhroniem datiem.
• Tradicionālie `for await...of` cikli: Jūs varat sasniegt līdzīgus rezultātus, izmantojot tradicionālos `for await...of` ciklus ar manuālu datu apstrādes loģiku. Tomēr šī pieeja var radīt izvērstāku un grūtāk uzturamu kodu.

Noslēgums

JavaScript asinhrono ģeneratoru palīgi piedāvā jaudīgu un elegantu veidu, kā strādāt ar asinhronām datu straumēm. Izprotot šos palīgus un to spēju tos apvienot, jūs varat rakstīt lasāmāku, uzturamāku un efektīvāku kodu plašam lietojumprogrammu klāstam. Šo moderno straumju utilītu pieņemšana dos jums iespēju ar pārliecību risināt sarežģītus datu apstrādes izaicinājumus un uzlabot savas JavaScript izstrādes prasmes mūsdienu dinamiskajā, globāli saistītajā pasaulē.